home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / X11R4 / cmds / X / ddx / Xsun / patches / sunIo.c.patch < prev    next >
Encoding:
Text File  |  1991-11-05  |  10.5 KB  |  371 lines
  1. *** /tmp/,RCSt1659773    Mon Nov  4 17:41:22 1991
  2. --- sunIo.c    Tue Jul 24 18:01:22 1990
  3. ***************
  4. *** 49,68 ****
  5.   
  6.   #include    "sun.h"
  7.   #include    "opaque.h"
  8.   
  9.   int            lastEventTime = 0;
  10. ! extern int    sunSigIO;
  11.   extern int      screenIsSaved;
  12.   extern void    SaveScreens();
  13.   
  14. ! #ifdef SUN_WINDOWS
  15. ! int    windowFd = 0;
  16. ! int    sunIgnoreEvent = TRUE;
  17. ! #define    INPBUFSIZE    128
  18. ! #endif SUN_WINDOWS
  19.   
  20.   /*-
  21.    *-----------------------------------------------------------------------
  22.    * TimeSinceLastInputEvent --
  23.    *    Function used for screensaver purposes by the os module.
  24.    *
  25. --- 49,85 ----
  26.   
  27.   #include    "sun.h"
  28.   #include    "opaque.h"
  29. + #include    <sys/time.h>
  30.   
  31.   int            lastEventTime = 0;
  32. ! extern int    spriteCheckInput;
  33.   extern int      screenIsSaved;
  34.   extern void    SaveScreens();
  35.   
  36. ! extern unsigned int    repeatLong, repeatShort;
  37.   
  38.   /*-
  39.    *-----------------------------------------------------------------------
  40. +  * sunInputAvail --
  41. +  *    This function is called from the scheduler whenever one of
  42. +  *    the devices we told it to look for has input waiting.
  43. +  *
  44. +  * Results:
  45. +  *    None.
  46. +  *
  47. +  * Side Effects:
  48. +  *    spriteCheckInput has its READ_INPUT flag set.
  49. +  *
  50. +  *-----------------------------------------------------------------------
  51. +  */
  52. + void
  53. + sunInputAvail()
  54. + {
  55. +     spriteCheckInput = 1;
  56. + }
  57. + 
  58. + /*-
  59. +  *-----------------------------------------------------------------------
  60.    * TimeSinceLastInputEvent --
  61.    *    Function used for screensaver purposes by the os module.
  62.    *
  63. ***************
  64. *** 106,285 ****
  65.   void
  66.   ProcessInputEvents ()
  67.   {
  68. !     register Firm_event    *ptrEvents,        /* Current pointer event */
  69. !                *kbdEvents;            /* Current keyboard event */
  70. !     register int        numPtrEvents,     /* Number of remaining pointer
  71. !                          * events */
  72. !                 numKbdEvents;       /* Number of remaining
  73. !                          * keyboard events */
  74. !     int                      nPE,                /* Original number of pointer
  75. !                          * events */
  76. !                 nKE;                /* Original number of
  77. !                          * keyboard events */
  78. !     Bool            PtrAgain,        /* need to (re)read */
  79. !                 KbdAgain;        /* need to (re)read */
  80. !     DevicePtr            pPointer;
  81. !     DevicePtr            pKeyboard;
  82. !     register PtrPrivPtr     ptrPriv;
  83. !     register KbPrivPtr        kbdPriv;
  84. !     Firm_event              *lastEvent;            /* Last event processed */
  85.       enum {
  86.       NoneYet, Ptr, Kbd
  87.       }                lastType = NoneYet;    /* Type of last event */
  88.   
  89. - #ifdef SUN_WINDOWS
  90. -     struct inputevent sunevents[INPBUFSIZE];
  91. -     register struct inputevent *se = sunevents, *seL;
  92. -     int         n;
  93. - #endif SUN_WINDOWS
  94. - 
  95. -     sunSigIO = 0;
  96.       pPointer = LookupPointerDevice();
  97.       pKeyboard = LookupKeyboardDevice();
  98.   
  99. -     if ( sunUseSunWindows() ) {
  100. - #ifdef SUN_WINDOWS
  101. -     if ((n=read(windowFd,sunevents,INPBUFSIZE*sizeof sunevents[0])) < 0 
  102. -                 && errno != EWOULDBLOCK) {
  103. -         /*
  104. -          * Error reading events; should do something. XXX
  105. -          */
  106. - /*debug*/
  107. -     ErrorF("ProcessInputEvents: read(windowFd)  n=%d\n",n);
  108. -         return;
  109. -     }
  110. - 
  111. -     if (autoRepeatKeyDown && autoRepeatReady && n <= 0) {
  112. -         /* fake a sunwindows kbd event */
  113. -         n = sizeof(struct inputevent);
  114. -         se->ie_code = AUTOREPEAT_EVENTID;
  115. -         tvplus(event_time(se), autoRepeatLastKeyDownTv,
  116. -                             autoRepeatDeltaTv);
  117. -         if (autoRepeatDebug)
  118. -             ErrorF("ProcessInputEvents: sw auto event\n");
  119. -     }
  120. - 
  121. -     for (seL = sunevents + (n/(sizeof sunevents[0]));  se < seL; se++) {
  122. -         if (screenIsSaved == SCREEN_SAVER_ON)
  123. -         SaveScreens(SCREEN_SAVER_OFF, ScreenSaverReset);
  124. -         lastEventTime = TVTOMILLI(event_time(se));
  125. - 
  126. -         /*
  127. -          * Decide whether or not to pay attention to events.
  128. -          * Ignore the events if the locator has exited X Display.
  129. -          */
  130. -         switch (event_id(se)) {
  131. -         case KBD_DONE:
  132. -             sunChangeKbdTranslation( pKeyboard, FALSE );
  133. -             break;
  134. -         case KBD_USE:
  135. -             sunChangeKbdTranslation( pKeyboard, TRUE );
  136. -             break;
  137. -         case LOC_WINENTER:
  138. -             sunIgnoreEvent = FALSE;
  139. -             break;
  140. -         case LOC_WINEXIT:
  141. -             sunIgnoreEvent = TRUE;
  142. -             break;
  143. -         }
  144. - 
  145. -         if (sunIgnoreEvent) {
  146. -         continue;
  147. -         }
  148. - 
  149. -         /*
  150. -          * Figure out the X device this event should be reported on.
  151. -          */
  152. -         switch (event_id(se)) {
  153. -         case LOC_MOVE:
  154. -         case MS_LEFT:
  155. -         case MS_MIDDLE:
  156. -         case MS_RIGHT:
  157. -             sunMouseProcessEventSunWin(pPointer,se);
  158. -             break;
  159. -         case LOC_WINEXIT:
  160. -         case LOC_WINENTER:
  161. -         case KBD_DONE:
  162. -         case KBD_USE:
  163. -             break;
  164. -         default:
  165. -             sunKbdProcessEventSunWin(pKeyboard,se);
  166. -             break;
  167. -         }
  168. -     }
  169. - #endif SUN_WINDOWS
  170. -     } 
  171. -     else {
  172.       ptrPriv = (PtrPrivPtr)pPointer->devicePrivate;
  173.       kbdPriv = (KbPrivPtr)pKeyboard->devicePrivate;
  174.       
  175. -     numPtrEvents = 0;
  176. -     PtrAgain = TRUE;
  177. -     numKbdEvents = 0;
  178. -     KbdAgain = TRUE;
  179. -     lastEvent = (Firm_event *)0;
  180. - 
  181.       /*
  182. !      * So long as one event from either device remains unprocess, we loop:
  183. !      * Take the oldest remaining event and pass it to the proper module
  184. !      * for processing. The DDXEvent will be sent to ProcessInput by the
  185. !      * function called.
  186.        */
  187. !     while (1) {
  188. !         /*
  189. !          * Get events from both the pointer and the keyboard, storing the number
  190. !          * of events gotten in nPE and nKE and keeping the start of both arrays
  191. !          * in pE and kE
  192. !          */
  193. !         if ((numPtrEvents == 0) && PtrAgain) {
  194. !         ptrEvents = (* ptrPriv->GetEvents) (pPointer, &nPE, &PtrAgain);
  195. !         numPtrEvents = nPE;
  196. !         }
  197. !         if ((numKbdEvents == 0) && KbdAgain) {
  198. !         kbdEvents = (* kbdPriv->GetEvents) (pKeyboard, &nKE, &KbdAgain);
  199. !         numKbdEvents = nKE;
  200. !         }
  201. !         if ((numPtrEvents == 0) && (numKbdEvents == 0))
  202. !         break;
  203. !         if (numPtrEvents && numKbdEvents) {
  204. !         if (timercmp (&kbdEvents->time, &ptrEvents->time, <)) {
  205.               if (lastType == Ptr) {
  206.               (* ptrPriv->DoneEvents) (pPointer, FALSE);
  207. -             }
  208. -             (* kbdPriv->ProcessEvent) (pKeyboard, kbdEvents);
  209. -             numKbdEvents--;
  210. -             lastEvent = kbdEvents++;
  211.               lastType = Kbd;
  212. !         } else {
  213.               if (lastType == Kbd) {
  214.               (* kbdPriv->DoneEvents) (pKeyboard, FALSE);
  215. -             }
  216. -             (* ptrPriv->ProcessEvent) (pPointer, ptrEvents);
  217. -             numPtrEvents--;
  218. -             lastEvent = ptrEvents++;
  219.               lastType = Ptr;
  220.           }
  221. !         } else if (numKbdEvents) {
  222. !         if (lastType == Ptr) {
  223. !             (* ptrPriv->DoneEvents) (pPointer, FALSE);
  224. !         }
  225. !         (* kbdPriv->ProcessEvent) (pKeyboard, kbdEvents);
  226. !         numKbdEvents--;
  227. !         lastEvent = kbdEvents++;
  228. !         lastType = Kbd;
  229.           } else {
  230. !         if (lastType == Kbd) {
  231. !             (* kbdPriv->DoneEvents) (pKeyboard, FALSE);
  232. !         }
  233. !         (* ptrPriv->ProcessEvent) (pPointer, ptrEvents);
  234. !         numPtrEvents--;
  235. !         lastEvent = ptrEvents++;
  236. !         lastType = Ptr;
  237.           }
  238.       }
  239.   
  240.       if (lastEvent) {
  241. -         lastEventTime = TVTOMILLI(lastEvent->time);
  242.           if (screenIsSaved == SCREEN_SAVER_ON) {
  243.           SaveScreens(SCREEN_SAVER_OFF, ScreenSaverReset);
  244.           }
  245. --- 123,177 ----
  246.   void
  247.   ProcessInputEvents ()
  248.   {
  249. !     register Mouse_Event    *events;         /* Array of events */
  250. !     register int          numEvents;        /* Number of events left */
  251. !     int                      nE;                /* Total number of events */
  252. !     DevicePtr            pPointer;        /* System pointer */
  253. !     DevicePtr            pKeyboard;        /* System keyboard */
  254. !     register PtrPrivPtr     ptrPriv;        /* Private data for pointer */
  255. !     register KbPrivPtr        kbdPriv;        /* Private data for keyboard */
  256. !     Mouse_Event          *lastEvent;        /* Last event processed */
  257.       enum {
  258.       NoneYet, Ptr, Kbd
  259.       }                lastType = NoneYet;    /* Type of last event */
  260.   
  261.       pPointer = LookupPointerDevice();
  262.       pKeyboard = LookupKeyboardDevice();
  263.       
  264.       ptrPriv = (PtrPrivPtr)pPointer->devicePrivate;
  265.       kbdPriv = (KbPrivPtr)pKeyboard->devicePrivate;
  266.       
  267.       /*
  268. !      * Get events from both the pointer and the keyboard via the keyboard's
  269. !      * GetEvents vector. The number of events read is stored in numEvents.
  270.        */
  271. !     events = (* kbdPriv->GetEvents) (pKeyboard, &nE);
  272. !     numEvents = nE;
  273. !     
  274. !     while (numEvents) {
  275. !     if (events->flags & KEYBOARD_EVENT) {
  276.           if (lastType == Ptr) {
  277.               (* ptrPriv->DoneEvents) (pPointer, FALSE);
  278.               lastType = Kbd;
  279. !         }
  280. !         (* kbdPriv->ProcessEvent) (pKeyboard, events);
  281. !     } else if (events->flags & MOUSE_EVENT) {
  282.           if (lastType == Kbd) {
  283.               (* kbdPriv->DoneEvents) (pKeyboard, FALSE);
  284.               lastType = Ptr;
  285.           }
  286. !         (* ptrPriv->ProcessEvent) (pPointer, events);
  287.       } else {
  288. !         /* ??? */
  289.       }
  290. +     lastEvent = events;
  291. +     lastEventTime = events->time;
  292. +     numEvents -= 1;
  293. +     events += 1;
  294.       }
  295.       
  296. +     SetTimeSinceLastInputEvent();
  297.       if (lastEvent) {
  298.       if (screenIsSaved == SCREEN_SAVER_ON) {
  299.           SaveScreens(SCREEN_SAVER_OFF, ScreenSaverReset);
  300.       }
  301. ***************
  302. *** 288,295 ****
  303.       (* kbdPriv->DoneEvents) (pKeyboard, TRUE);
  304.       (* ptrPriv->DoneEvents) (pPointer, TRUE);
  305.   
  306. !     }
  307. ! 
  308.   }
  309.   
  310.   
  311. --- 180,186 ----
  312.       (* kbdPriv->DoneEvents) (pKeyboard, TRUE);
  313.       (* ptrPriv->DoneEvents) (pPointer, TRUE);
  314.   
  315. !     spriteCheckInput = 0;
  316.   }
  317.   
  318.   
  319. ***************
  320. *** 341,357 ****
  321.   
  322.       if (strcmp (argv[i], "-ar1") == 0) {    /* -ar1 int */
  323.       if (++i >= argc) UseMsg ();
  324. !     autoRepeatInitiate = 1000 * (long)atoi(argv[i]);
  325.       return 2;
  326.       }
  327.       if (strcmp (argv[i], "-ar2") == 0) {    /* -ar2 int */
  328.       if (++i >= argc) UseMsg ();
  329. !     autoRepeatDelay = 1000 * (long)atoi(argv[i]);
  330.       return 2;
  331.       }
  332.       if (strcmp (argv[i], "-debug") == 0) {    /* -debug */
  333.       return 1;
  334.       }
  335.       if (strcmp (argv[i], "-dev") == 0) {    /* -dev /dev/mumble */
  336.       if (++i >= argc) UseMsg ();
  337.       return 2;
  338. --- 232,250 ----
  339.   
  340.       if (strcmp (argv[i], "-ar1") == 0) {    /* -ar1 int */
  341.       if (++i >= argc) UseMsg ();
  342. !     repeatLong = 1000 * (long)atoi(argv[i]);
  343.       return 2;
  344.       }
  345.       if (strcmp (argv[i], "-ar2") == 0) {    /* -ar2 int */
  346.       if (++i >= argc) UseMsg ();
  347. !     repeatShort = 1000 * (long)atoi(argv[i]);
  348.       return 2;
  349.       }
  350. + #ifndef    sprite
  351.       if (strcmp (argv[i], "-debug") == 0) {    /* -debug */
  352.       return 1;
  353.       }
  354. + #endif    sprite
  355.       if (strcmp (argv[i], "-dev") == 0) {    /* -dev /dev/mumble */
  356.       if (++i >= argc) UseMsg ();
  357.       return 2;
  358. ***************
  359. *** 371,378 ****
  360. --- 264,273 ----
  361.   {
  362.       ErrorF("-ar1 int               set autorepeat initiate time\n");
  363.       ErrorF("-ar2 int               set autorepeat interval time\n");
  364. + #ifndef    sprite
  365.       ErrorF("-debug                 disable non-blocking console mode\n");
  366.       ErrorF("-dev filename          name of device to open\n");
  367. + #endif    sprite
  368.       ErrorF("-mono                  force monochrome-only screen\n");
  369.       ErrorF("-zaphod                disable active Zaphod mode\n");
  370.   }
  371.